דפוסי מאגר מודולים של JavaScript: גישה מאובטחת ויעילה לנתונים

            
// user_repository_interface.js

export class IUserRepository {
  async getUserById(id) {
    throw new Error("Method 'getUserById()' must be implemented.");
  }

  async getAllUsers() {
    throw new Error("Method 'getAllUsers()' must be implemented.");
  }

  async createUser(user) {
    throw new Error("Method 'createUser()' must be implemented.");
  }

  async updateUser(id, user) {
    throw new Error("Method 'updateUser()' must be implemented.");
  }

  async deleteUser(id) {
    throw new Error("Method 'deleteUser()' must be implemented.");
  }
}

            

              
                Copy
              
            
          

            
// user_repository_interface.ts

export interface IUserRepository {
  getUserById(id: string): Promise;
  getAllUsers(): Promise;
  createUser(user: User): Promise;
  updateUser(id: string, user: User): Promise;
  deleteUser(id: string): Promise;
}

            

              
                Copy
              
            
          

            
// user_repository.js
import mongoose from 'mongoose';
import { IUserRepository } from './user_repository_interface.js';
const UserSchema = new mongoose.Schema({
  name: String,
  email: String,
});
const UserModel = mongoose.model('User', UserSchema);

export class UserRepository extends IUserRepository {
  constructor(dbUrl) {
        super();
        mongoose.connect(dbUrl).catch(err => console.log(err));
    }
  async getUserById(id) {
    try {
      return await UserModel.findById(id).exec();
    } catch (error) {
      console.error("Error getting user by ID:", error);
      return null; // Or throw the error, depending on your error handling strategy
    }
  }

  async getAllUsers() {
    try {
      return await UserModel.find().exec();
    } catch (error) {
      console.error("Error getting all users:", error);
      return []; // Or throw the error
    }
  }

  async createUser(user) {
    try {
      const newUser = new UserModel(user);
      return await newUser.save();
    } catch (error) {
      console.error("Error creating user:", error);
      throw error; // Rethrow the error to be handled upstream
    }
  }

  async updateUser(id, user) {
    try {
      return await UserModel.findByIdAndUpdate(id, user, { new: true }).exec();
    } catch (error) {
      console.error("Error updating user:", error);
      return null; // Or throw the error
    }
  }

  async deleteUser(id) {
    try {
      const result = await UserModel.findByIdAndDelete(id).exec();
      return !!result; // Return true if the user was deleted, false otherwise
    } catch (error) {
      console.error("Error deleting user:", error);
      return false; // Or throw the error
    }
  }
}

            

              
                Copy
              
            
          

            
// user_repository.ts
import { Sequelize, DataTypes, Model } from 'sequelize';
import { IUserRepository } from './user_repository_interface.ts';

interface UserAttributes {
  id: string;
  name: string;
  email: string;
}

interface UserCreationAttributes extends Omit {}

class User extends Model implements UserAttributes {
  public id!: string;
  public name!: string;
  public email!: string;

  public readonly createdAt!: Date;
  public readonly updatedAt!: Date;
}

export class UserRepository implements IUserRepository {
  private sequelize: Sequelize;
  private UserModel: typeof User; // Store the Sequelize Model

  constructor(sequelize: Sequelize) {
    this.sequelize = sequelize;
    this.UserModel = User.init(
      {
        id: {
          type: DataTypes.UUID,
          defaultValue: DataTypes.UUIDV4,
          primaryKey: true,
        },
        name: {
          type: DataTypes.STRING,
          allowNull: false,
        },
        email: {
          type: DataTypes.STRING,
          allowNull: false,
          unique: true,
        },
      },
      {
        tableName: 'users',
        sequelize: sequelize, // Pass the Sequelize instance
      }
    );
  }

  async getUserById(id: string): Promise {
    try {
      return await this.UserModel.findByPk(id);
    } catch (error) {
      console.error("Error getting user by ID:", error);
      return null;
    }
  }

  async getAllUsers(): Promise {
    try {
      return await this.UserModel.findAll();
    } catch (error) {
      console.error("Error getting all users:", error);
      return [];
    }
  }

  async createUser(user: UserCreationAttributes): Promise {
    try {
      return await this.UserModel.create(user);
    } catch (error) {
      console.error("Error creating user:", error);
      throw error;
    }
  }

  async updateUser(id: string, user: UserCreationAttributes): Promise {
    try {
      const [affectedCount] = await this.UserModel.update(user, { where: { id } });
      if (affectedCount === 0) {
        return null; // No user found with that ID
      }
      return await this.UserModel.findByPk(id);
    } catch (error) {
      console.error("Error updating user:", error);
      return null;
    }
  }

  async deleteUser(id: string): Promise {
    try {
      const deletedCount = await this.UserModel.destroy({ where: { id } });
      return deletedCount > 0; // Returns true if a user was deleted
    } catch (error) {
      console.error("Error deleting user:", error);
      return false;
    }
  }
}

            

              
                Copy
              
            
          

            
// user_service.js

export class UserService {
  constructor(userRepository) {
    this.userRepository = userRepository;
  }

  async getUserProfile(userId) {
    const user = await this.userRepository.getUserById(userId);
    if (!user) {
      throw new Error("User not found");
    }
    return {
      id: user._id,
      name: user.name,
      email: user.email,
    };
  }

  async createUser(userData) {
    // Validate user data before creating
    if (!userData.name || !userData.email) {
      throw new Error("Name and email are required");
    }
    return this.userRepository.createUser(userData);
  }

  // Other service methods...
}

            

              
                Copy
              
            
          

            
// user_service.ts
import { IUserRepository } from './user_repository_interface.ts';
import { User } from './models/user.ts';

export class UserService {
  private userRepository: IUserRepository;

  constructor(userRepository: IUserRepository) {
    this.userRepository = userRepository;
  }

  async getUserProfile(userId: string): Promise {
    const user = await this.userRepository.getUserById(userId);
    if (!user) {
      throw new Error("User not found");
    }
    return user;
  }

  async createUser(userData: Omit): Promise {
    // Validate user data before creating
    if (!userData.name || !userData.email) {
      throw new Error("Name and email are required");
    }
    return this.userRepository.createUser(userData);
  }

  // Other service methods...
}

            

              
                Copy
              
            
          

            
// app.js
import { UserService } from './user_service.js';
import { UserRepository } from './user_repository.js';

// Replace with your MongoDB connection string
const dbUrl = 'mongodb://localhost:27017/mydatabase';

const userRepository = new UserRepository(dbUrl);
const userService = new UserService(userRepository);

async function main() {
  try {
    const newUser = await userService.createUser({ name: 'John Doe', email: 'john.doe@example.com' });
    console.log('Created user:', newUser);

    const userProfile = await userService.getUserProfile(newUser._id);
    console.log('User profile:', userProfile);
  } catch (error) {
    console.error('Error:', error);
  }
}

main();

            

              
                Copy
              
            
          

            
// product_repository_interface.ts
export interface IProductRepository {
  getProductById(id: string): Promise;
  getAllProducts(): Promise;
  getProductsByCategory(category: string): Promise;
  createProduct(product: Product): Promise;
  updateProduct(id: string, product: Product): Promise;
  deleteProduct(id: string): Promise;
}

            

              
                Copy
              
            
          

            
// product_repository.ts
import { IProductRepository } from './product_repository_interface.ts';
import { Product } from './models/product.ts'; // Assuming you have a Product model

export class ProductRepository implements IProductRepository {
  // Assume a database connection or ORM is initialized elsewhere
  private db: any; // Replace 'any' with your actual database type or ORM instance

  constructor(db: any) {
    this.db = db;
  }

  async getProductById(id: string): Promise {
    try {
      // Assuming 'products' table and appropriate query method
      const product = await this.db.products.findOne({ where: { id } });
      return product;
    } catch (error) {
      console.error("Error getting product by ID:", error);
      return null;
    }
  }

  async getAllProducts(): Promise {
    try {
      const products = await this.db.products.findAll();
      return products;
    } catch (error) {
      console.error("Error getting all products:", error);
      return [];
    }
  }

  async getProductsByCategory(category: string): Promise {
    try {
      const products = await this.db.products.findAll({ where: { category } });
      return products;
    } catch (error) {
      console.error("Error getting products by category:", error);
      return [];
    }
  }

  async createProduct(product: Product): Promise {
    try {
      const newProduct = await this.db.products.create(product);
      return newProduct;
    } catch (error) {
      console.error("Error creating product:", error);
      throw error;
    }
  }

  async updateProduct(id: string, product: Product): Promise {
    try {
      // Update the product, return the updated product or null if not found
      const [affectedCount] = await this.db.products.update(product, { where: { id } });
      if (affectedCount === 0) {
        return null;
      }
      const updatedProduct = await this.getProductById(id);
      return updatedProduct;
    } catch (error) {
      console.error("Error updating product:", error);
      return null;
    }
  }

  async deleteProduct(id: string): Promise {
    try {
      const deletedCount = await this.db.products.destroy({ where: { id } });
      return deletedCount > 0; // True if deleted, false if not found
    } catch (error) {
      console.error("Error deleting product:", error);
      return false;
    }
  }
}

            

              
                Copy
              
            
          

            
// product_service.ts
import { IProductRepository } from './product_repository_interface.ts';
import { Product } from './models/product.ts';

export class ProductService {
  private productRepository: IProductRepository;

  constructor(productRepository: IProductRepository) {
    this.productRepository = productRepository;
  }

  async getProductDetails(productId: string): Promise {
    // Add business logic, such as checking product availability
    const product = await this.productRepository.getProductById(productId);
    if (!product) {
      return null; // Or throw an exception
    }
    return product;
  }

  async listProductsByCategory(category: string): Promise {
    // Add business logic, such as filtering by featured products
    return this.productRepository.getProductsByCategory(category);
  }

  async createNewProduct(productData: Omit): Promise {
    // Perform validation, sanitization, etc.
    return this.productRepository.createProduct(productData);
  }

  // Add other service methods for updating, deleting products, etc.
}

            

              
                Copy